As the docs currently state about shared enums:
> Pattern matching with match still works but will require you to write
> wildcard arms to handle the situation of an enum value that is not
> one of the listed variants.

This is unfortunate as there is no way to check that all listed enum
variants are actually handled. IOW this code does not even warn:
```
mod ffi {
    enum Enum {
        A,
        B,
        C = 5,
    }
}

match t {
    Enum::A => {},
    Enum::B => {},
    _ => {},
}
```

This generates an extra _Enum! macro that matches all the ranges that
are _not_ listed by the enum. When using that macro instead of the _
catch-all, we get compile-time errors if we forget to match variants:
```
match t {
    Enum::A => {},
    Enum::B => {},
    _Enum!() => {},
}
// Error Enum{ repr: 5 } case not covered
```

The generated macro looks like:
```
macro_rules! _Enum {
    () => { Enum{ repr: 4..5 | 6.. } };
    ($i:ident) => { Enum { repr: $i @ 4..5 | 6.. } };
}
```

It can also be used to ergonomically retrieve the inner value in the
unlisted case:
```
match t {
    Enum::A => {},
    Enum::B => {},
    Enum::C => {},
    _Enum!(value) => panic!("Unexpected Enum value {value}"),
}
```